#pragma once
#include "VMAC_OP_enum.h"
#include "../../instruction_module/instruction.h"
#include"../../execution_module/write_delay_control/write_delay_control.h"
#include <iostream>
#include "../../System_config.h"


class VMAC {
public:
    VMAC(std::vector<base_operand*>* operands, int vmac_id) 
                : operand_list(operands), id(vmac_id){
        delay_cycles = 1;
    }
    VMAC(int vmac_id, RegisterFile* rf) : id(vmac_id), RF(rf) {
        delay_cycles = 1;
    }
    ~VMAC() {}
    int get_delay();
    void input_operands(std::vector<base_operand*>* operands);
    uint64_t Execute(instruction* vmac_instr);
    write_req_info_reg  upload_write_msg();
    inline uint64_t read_Reg(int reg_id);
    inline void write_Reg(int reg_id, uint64_t value, int delay);
    inline uint64_t do_VFMULD(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFMULS32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFMULAD(int src1_reg_id, int src2_reg_id, int src3_reg_id, int dst_reg_id);
    inline uint64_t do_VFMULAS32(int src1_reg_id, int src2_reg_id, int src3_reg_id, int dst_reg_id);
    inline uint64_t do_VFMULBD(int src1_reg_id, int src2_reg_id, int src3_reg_id, int dst_reg_id);
    inline uint64_t do_VFMULBS32(int src1_reg_id, int src2_reg_id, int src3_reg_id, int dst_reg_id);
    inline uint64_t do_VFDOT32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFCREAL32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFCIMAG32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFADDH16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFSUBH16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFMULH16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFMULAH16(int src1_reg_id, int src2_reg_id, int src3_reg_id, int dst_reg_id);
    inline uint64_t do_VFMULBH16(int src1_reg_id, int src2_reg_id, int src3_reg_id, int dst_reg_id);
    inline uint64_t do_VFCMPEH16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFCMPGH16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFCMPLH16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFHINT16(int src_reg_id, int dst_reg_id); //不确定舍入方式
    inline uint64_t do_VFHTRU16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFINTH16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFINTHU16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFSPHP16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFHPSP16L(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFHPSP16H(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFMANH16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFLOGH16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFABSH16(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFMAX16(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFEXTS32L(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFEXTS32H(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFEXTH16LL(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFEXTH16LH(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFEXTH16HL(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFEXTH16HH(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VMOV(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VMOVI(uint64_t imm, int dst_reg_id);
    inline uint64_t do_VFCMPED(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFCMPES32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFCMPGD(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFCMPGS32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFCMPLD(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFCMPLS32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFDINT(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFSINT32(int src_reg_id, int dst_reg_id); //分别存放？
    inline uint64_t do_VFDTRU(int src_reg_id, int dst_reg_id); //???
    inline uint64_t do_VFSTRU32(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFINTD(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFINTDU(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFINTS32(int src_reg_id, int dst_reg_id); //???
    inline uint64_t do_VFINTSU32(int src_reg_id, int dst_reg_id); //???
    inline uint64_t do_VFDPSP32(int src1_reg_id, int src2_reg_id, int dst_reg_id);
    inline uint64_t do_VFSPDP32T(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFSPHDP32T(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFMAND(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFMANS32(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFLOGD(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFLOGS32(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFABSD(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFABSS32(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFRSQD(int src_reg_id, int dst_reg_id); //以下没整明白描述
    inline uint64_t do_VFRSQS32(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFRCPD(int src_reg_id, int dst_reg_id);
    inline uint64_t do_VFRCPS32(int src_reg_id, int dst_reg_id);
    /* 双精度浮点操作数 Src 的倒数平方根近似值存入目的寄存器 Dst（64 位双精度浮点数）中。源操作数 Src 来源于局部寄存器，目的操作数存入局部寄存器。
    根据尾数的高 8 位查表可以得到精确度为 2-8 精度的结果，然后将这个结果根据Newton-Rhason 迭代公式来增加精度：X[n+1] = X[n](1.5-(v/2)*X[n] *X[n]) 
    每迭代一次精度增加一倍。其中 V 的倒数平方根已经查表 RSQRTable 查出。
    执行语义
    if(cond) sqrcp(Src) ->Dst //sqrcp 表示求源操作数的平方根倒数
    else nop*/



private:
    // //此处VMAC内部存储输入的值而不是寄存器编号，目的是方便VMAC类更好地去计算
    // //读取寄存器的功能放到VPU类内部，再将16*64的寄存器读取结果分配给16个VMAC
    // double src_1;
    // double src_2;
    // double src_3;
    int id; //表明该VMAC所属的VPE是16个并列的VPE中的第几个，用于操作向量寄存器（确定操作16个一组的第几个寄存器
    std::vector<base_operand*>* operand_list;
    //!delay应修改为与指令绑定，同一个硬件模块可能执行多个指令，有着不同的延迟周期
    //以下三个private成员为每个步进周期内，存储写入结果的临时变量
    uint64_t res_value;
    int dst_reg_id;
    int delay_cycles; //用于标记该硬件单元从接收到输入，直到给出输出的延迟周期，根据不同的指令类型，应有不同的延迟周期

    RegisterFile* RF;

    static inline float int16_to_float(int16_t v) {
        float f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

//     float fp16_to_float(uint16_t fp16) {
//     // 实现 fp16 到 float 的转换逻辑
//     // 这里可以使用库函数或手动实现
//     // 以下是一个简单的示例实现（假设 fp16 是 IEEE 754 半精度格式）
//     uint32_t sign = (fp16 >> 15) & 0x1;
//     uint32_t exponent = (fp16 >> 10) & 0x1F;
//     uint32_t mantissa = fp16 & 0x3FF;

//     if (exponent == 0) {
//         // 零或非规格化数
//         return (sign ? -0.0f : 0.0f);
//     } else if (exponent == 0x1F) {
//         // 无穷大或 NaN
//         return (mantissa == 0) ? (sign ? -INFINITY : INFINITY) : NAN;
//     } else {
//         // 规格化数
//         exponent -= 15; // 调整指数偏移
//         mantissa |= 0x400; // 添加隐含的 1
//         float value = std::ldexp(mantissa, exponent - 10);
//         return sign ? -value : value;
//     }
// }

inline static int countl_zero(uint32_t x) {
    int n = 0;
    if (x == 0) return 32;
    while ((x & 0x80000000) == 0) {
        n++;
        x <<= 1;
    }
    return n;
}
// f16的格式定义：https://en.wikipedia.org/wiki/Half-precision_floating-point_format
// f32的格式定义：https://en.wikipedia.org/wiki/Single-precision_floating-point_format
// Fraction和man、Significand、mantissa 指的同一个东西，都是尾数位，F16的最后10位，F32的最后23位。
static float fp16_to_float(uint16_t i)
{
    // Check for signed zero, 根据F16的表示规则，如果Exponent(5位)和Significand(10位)都为0，那么表示浮点数zero, -0
    // 转换成f32只需要向右移16位构成32位表示就可以了，即符号位+31位0
    if ((i & 0x7FFF) == 0)
    {
        uint32_t result = (static_cast<uint32_t>(i) << 16);
        float f = 0.0;
        std::memset(&f, 0, sizeof(f));
        std::memcpy(&f, &result, sizeof(result));
        return f;
    }

    // 根据f16的IEEE754-2008标准，获取sign，Exponent，Significand的值
    uint32_t half_sign = (i & 0x8000);
    uint32_t half_exp = (i & 0x7C00);
    uint32_t half_man = (i & 0x03FF);

    // Check for an infinity or NaN when all exponent bits set
    // 如果Exponent（5位）对应的bit位全是1，即11111，那么可能是infinity or NaN 
    if (half_exp == 0x7C00)
    {
        // 如果Significand（10位）是0，就表示+-infinity（无穷）
        // Check for signed infinity if mantissa is zero
        if (half_man == 0)
        {
            // 转换位float32就是，符号位 + float32的+-infinity表示
            // 即符号位：（half_sign << 16）
            // float32的+-infinity表示： Exponent（占用8bit）全为1，fraction（23bit）全为0，即0x7F800000
            uint32_t result = (half_sign << 16) | 0x7F800000;
            float f = 0.0;
            std::memset(&f, 0, sizeof(f));
            std::memcpy(&f, &result, sizeof(result));
            return f;
        }
        else
        {
            // 如果Significand（10位）不是0， 就表示NaN
            // 转换为对应Float32的NaN，即Exponent（占用8bit）全为1；fraction（23bit）为half_man右移动13位（f32的fraction表示位数减去f16的fraction表示的位数，即23 - 10等于13）
            // NaN, keep current mantissa but also set most significiant mantissa bit
            // 为啥不是 0x7F800000??? 
            uint32_t result = (half_sign << 16) | 0x7FC00000 | (half_man << 13);
            float f = 0.0;
            std::memset(&f, 0, sizeof(f));
            std::memcpy(&f, &result, sizeof(result));
            return f;
        }
    }

    // Calculate single-precision components with adjusted exponent
    // 转换为f32的符号位，右移动16位
    uint32_t sign = half_sign << 16;
    // Unbias exponent
    // 因为F16的Exponent的表示的不是e为底，Exponent为指数的指数函数，而是指数为Exponent-15，偏移量为15
    // 对应F32的偏移量为127，所以换成F32的Exponent就要E - 15 + 127表示
    int32_t unbiased_exp = (static_cast<int32_t>(half_exp) >> 10) - 15;
    
    // 通过前面的条件过滤，这里表示Exponent全为0，Significand不全为0，表示subnormal number
    // Check for subnormals, which will be normalized by adjusting exponent
    if (half_exp == 0)
    {
        // Calculate how much to adjust the exponent by
        int e = countl_zero(half_man) - 6;

        // Rebias and adjust exponent
        uint32_t exp = (127 - 15 - e) << 23;
        uint32_t man = (half_man << (14 + e)) & 0x7FFFFF;
        uint32_t result = sign | exp | man;
        float f = 0.0;
        std::memset(&f, 0, sizeof(f));
        std::memcpy(&f, &result, sizeof(result));
        return f;
    }

    // Rebias exponent for a normalized normal
    // 这里的加127，对应上面说的F16转F32时Exponent要加上F32的Exponent偏移量127；向右移动23位到达表示Exponent对应的bit位置
    uint32_t exp = (static_cast<uint32_t>(unbiased_exp + 127)) << 23;
    // 向右移动13位，Significand值由F16的10位表示转换成23位表示
    uint32_t man = (half_man & 0x03FF) << 13;
    uint32_t result = sign | exp | man;
    float f = 0.0;
    std::memset(&f, 0, sizeof(f));
    std::memcpy(&f, &result, sizeof(result));
    return f;
}

// Fraction和man、Significand、mantissa 指的同一个东西，都是尾数位，F16的最后10位，F32的最后23位。
// In the below functions, round to nearest, with ties to even.
// Let us call the most significant bit that will be shifted out the round_bit.
//
// Round up if either
//  a) Removed part > tie.
//     (mantissa & round_bit) != 0 && (mantissa & (round_bit - 1)) != 0
//  b) Removed part == tie, and retained part is odd. F32的Fraction右移动13位后，剩下部分是奇数，可以进位
//     (mantissa & round_bit) != 0 && (mantissa & (2 * round_bit)) != 0
// F32的Fraction右移动13位后，剩下部分是奇数，可以进位
// (If removed part == tie and retained part is even, do not round up.)
// These two conditions can be combined into one:
//     (mantissa & round_bit) != 0 && (mantissa & ((round_bit - 1) | (2 * round_bit))) != 0
// which can be simplified into
//     (mantissa & round_bit) != 0 && (mantissa & (3 * round_bit - 1)) != 0
static uint16_t float_to_fp16(float value)
{
    // Convert to raw bytes
    uint32_t x;
    std::memset(&x, 0, sizeof(uint32_t));
    std::memcpy(&x, &value, sizeof x);

    // Extract IEEE754 components
    uint32_t sign = x & 0x80000000u;
    uint32_t exp = x & 0x7F800000u;
    uint32_t man = x & 0x007FFFFFu;

    // Check for all exponent bits being set, which is Infinity or NaN
    // Exponent全为1，表示Infinity or NaN
    if (exp == 0x7F800000u)
    {
        uint32_t nan_bit = (man == 0) ? 0 : 0x0200u;
        // 0x7C00u 表示F16的Exponent全为1
        // nan_bit：如果man==0，表示+-infinity，所以直接把(man >> 13)就变成了F16的man
        // 如果man != 0, 把（man >> 13）可能变成了0，所以加上一个nan_bit，确保转换成的F16！=0
        return (sign >> 16) | 0x7C00u | nan_bit | (man >> 13);
    }

    // 右移16bit转换成F16的sign
    uint32_t half_sign = sign >> 16;
    // 127是F32的Exponent的偏移
    // 从F32的Exponent转换成F16，就需要exp的值 - 127 + 15, 15是F16的偏移
    int32_t unbiased_exp = ((exp >> 23) - 127);
    int32_t half_exp = unbiased_exp + 15;

    // 表示half_exp超过F16的Exponent最大表示，11111
    // Check for exponent overflow, return +infinity
    // 表示infinity
    if (half_exp >= 0x1F)
    {
        // 0x7C00u表示，F16表示的bit位，Fraction全部为0, Exponent全部为1
        return half_sign | 0x7C00u;
    }

    // Check for underflow
    if (half_exp <= 0)
    {
        // Check mantissa for what we can do
        if ((14 - half_exp) > 24)
        {
            // No rounding possibility, so this is a full underflow, return signed zero
            return half_sign;
        }
        man = man | 0x00800000u;
        uint32_t half_man = man >> (14 - half_exp);
        uint32_t round_bit = 1 << (13 - half_exp);
        if ((man & round_bit) != 0 && (man & (3 * round_bit - 1)) != 0)
        {
            half_man++;
        }
        return half_sign | half_man;
    }
    // Rebias the exponent, 左移10位到F16的Exponent表示位置
    half_exp = (half_exp << 10);
    // 右移动13位，到F16的Significand表示位置
    uint32_t half_man = man >> 13;
    // round_bit表示F32的Fraction中的从右往左的第13位，也就是转换成F16（10位）时要移除的最后一个位置。
    uint32_t round_bit = 0x00001000u;
    // Check for rounding (see comment above functions)
    if ((man & round_bit) != 0 && (man & (3 * round_bit - 1)) != 0)
    {
        // Round it
        return (half_sign | half_exp | half_man) + (uint32_t)1;
    }
    else
    {
        return half_sign | half_exp | half_man;
    }
}


//     //ai写的
//     uint16_t float_to_fp16(float value) {
//     // 实现 float 到 fp16 的转换逻辑
//     // 这里可以使用库函数或手动实现
//     // 以下是一个简单的示例实现（假设 fp16 是 IEEE 754 半精度格式）
//     uint32_t bits = *reinterpret_cast<uint32_t*>(&value);
//     uint32_t sign = (bits >> 31) & 0x1;
//     uint32_t exponent = (bits >> 23) & 0xFF;
//     uint32_t mantissa = bits & 0x7FFFFF;

//     if (exponent == 0xFF) {
//         // 无穷大或 NaN
//         return (sign << 15) | 0x7C00 | (mantissa ? 0x200 : 0);
//     } else if (exponent == 0) {
//         // 零或非规格化数
//         return (sign << 15);
//     } else {
//         // 规格化数
//         exponent -= 127; // 调整指数偏移
//         if (exponent > 15) {
//             // 溢出，返回无穷大
//             return (sign << 15) | 0x7C00;
//         } else if (exponent < -14) {
//             // 非规格化数
//             return (sign << 15);
//         } else {
//             // 规格化数
//             exponent += 15; // 调整指数偏移
//             mantissa >>= 13; // 截断尾数
//             return (sign << 15) | (exponent << 10) | mantissa;
//         }
//     }
// }

    static inline float uint32_to_float(uint32_t v) {
        float f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline float int32_to_float(int32_t v) {
        float f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline uint32_t float_to_uint32(float f) {
        uint32_t v;
        std::memcpy(&v, &f, sizeof(v));
        return v;
    }

    static inline int32_t float_to_int32(float f) {
        int32_t v;
        std::memcpy(&v, &f, sizeof(v));
        return v;
    }

    static inline float double_to_float(double v) {
        float f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline float float_to_double(float v) {
        double f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }


    static inline double uint64_to_double(uint64_t v) {
        double f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline double uint64_to_float(uint64_t v) {
        float f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline double int64_to_double(int64_t v) {
        double f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline int64_t double_to_int64(double v) {
        int64_t f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline int64_t double_to_uint64(double v) {
        uint64_t f;
        std::memcpy(&f, &v, sizeof(f));
        return f;
    }

    static inline uint64_t fraction_16(uint16_t fp16) {
        uint64_t fp16_1 = static_cast<uint64_t>(fp16 & 0x03FF);
        uint64_t fp16_2 = fp16_1 || 0x0400; //加上隐含的1
        uint64_t fp16_3 = fp16_2 << 4;
        return fp16_3;
    }

    static inline uint64_t fraction_32(uint32_t f) {
        uint64_t f_1 = static_cast<uint64_t>(f & 0x007FFFFF);
        uint64_t f_2 = f_1 || 0x00800000; //加上隐含的1
        uint64_t f_3 = f_2 << 7;
        return f_3;
    }

    static inline uint64_t exponent(uint16_t fp16) {
        uint64_t exp_1 = static_cast<uint64_t>((fp16 & 0x7C00) >> 10);
        uint64_t exp_2 = exp_1 - 15;
        return exp_2;
    }

    //求倒数平方根近似值
    double sqrcp(double x) {
        const float threehalfs = 1.5F;

        double xhalf = 0.5F * x;
        int i = *(int*)&x;  // 将浮点数的二进制表示转换为整数
        i = 0x5f3759df - (i >> 1);  // 魔法常数和位运算
        x = *(double*)&i;  // 将整数转换回浮点数
        x = x * (threehalfs - (xhalf * x * x));  // 牛顿迭代逼近

        return x;
    }

    // 有符号16位整数转浮点数 ???ai写的
    static float int16_to_float(int16_t i){
        // 处理零的情况
        if (i == 0){
            return 0.0f;
        }

        // 提取符号和绝对值
        uint32_t sign = (static_cast<uint32_t>(i) & 0x8000) << 16;
        uint32_t abs_value = static_cast<uint32_t>(i < 0 ? -i : i);

        // 对于有符号16位整数，值范围是-32768到32767
        // 找到最高位1的位置（规范化）
        int exponent;
        uint32_t mantissa;
    
        if (abs_value < 0x80) {
            exponent = 127 + 6; // 偏移127 + (7-1)
            mantissa = (abs_value << 16) & 0x7FFFFF;
        } else if (abs_value < 0x800) {// 128-2047, 需要11位
            exponent = 127 + 10; // 偏移127 + (11-1)
            mantissa = (abs_value << 12) & 0x7FFFFF;
        } else {// 2048-32767, 需要15位
            exponent = 127 + 14; // 偏移127 + (15-1)
            mantissa = (abs_value << 8) & 0x7FFFFF;
        }

        // 组合结果
        uint32_t result = sign | (static_cast<uint32_t>(exponent) << 23) | mantissa;
    
        float f;
        std::memcpy(&f, &result, sizeof(result));
        return f;
    }
    
    // 浮点数转有符号16位整数
    static int16_t float_to_int16(float value){
        // Convert to raw bytes
        uint32_t x;
        std::memset(&x, 0, sizeof(uint32_t));
        std::memcpy(&x, &value, sizeof x);

        // Extract IEEE754 components
        uint32_t sign = x & 0x80000000u;
        uint32_t exp = x & 0x7F800000u;
        uint32_t man = x & 0x007FFFFFu;

        // Check for special cases: NaN, Infinity, Zero
        // 处理NaN和无穷大，转换为0
        if (exp == 0x7F800000u) {
            // NaN or Infinity, clamp to 0
            return 0;
        }

        // 处理0
        if (exp == 0 && man == 0) {
            return 0;
        }

        // Calculate actual float value: (-1)^sign * (1 + man/2^23) * 2^(exp-127)
        int32_t unbiased_exp = ((exp >> 23) - 127);
        
        // 如果指数太小，值小于1，直接返回0
        if (unbiased_exp < 0) {
            return 0;
        }

        // 如果指数太大，值超过int16范围，进行饱和处理
        if (unbiased_exp > 14) {  // 2^15 = 32768 是 int16 的最大绝对值+1
            if (sign)
            {
                return -32768;  // INT16_MIN
            }
            else
            {
                return 32767;   // INT16_MAX
            }
        }

        // 计算实际数值
        // 将尾数转换为整数部分，加上隐含的1
        uint32_t full_mantissa = man | 0x00800000u;
    
        // 根据指数调整尾数
        int32_t shift_amount = 23 - unbiased_exp;
        uint32_t integer_part;
        
        if (shift_amount >= 0)
        {
            integer_part = full_mantissa >> shift_amount;
        }
        else
        {
            integer_part = full_mantissa << (-shift_amount);
        }

        // 处理舍入
        uint32_t round_bit = 1u << (shift_amount - 1);
        if ((man & round_bit) != 0)
        {
            // 检查是否需要向上舍入
            if ((man & (round_bit - 1)) != 0 || (integer_part & 1) != 0)
            {
                integer_part++;
            }
        }
        // 应用符号
        int32_t result;
        if (sign)
        {
            result = -static_cast<int32_t>(integer_part);
            // 饱和处理负方向的溢出
            if (result < -32768)
            {
                return -32768;
            }
        }
        else
        {
            result = static_cast<int32_t>(integer_part);
            // 饱和处理正方向的溢出
            if (result > 32767)
            {
                return 32767;
            }
        }

        return static_cast<int16_t>(result);
    }
};
